It doesn't look like `errors.join is necessary here, since we're only ever have one error. From what I can tell this is all that's necessary in this case:

	err := setTaskRunStatusBasedOnStepStatus(ctx, logger, stepStatuses, &tr, pod.Status.Phase, kubeclient, ts)

	setTaskRunStatusBasedOnSidecarStatus(sidecarStatuses, trs)

	trs.Results = removeDuplicateResults(trs.Results)

	return *trs, err

Since we're joining them all at the end anyway, any reason we're not going something like this?

var errs error
slr, err := sidecarlogresults.GetResultsFromSidecarLogs(ctx, kubeclient, tr.Namespace, tr.Status.PodName, pipeline.ReservedResultsSidecarContainerName, podPhase)
errs = errors.Join(errs, err) // note that errors.Join handles err being nil internally :)
...
err = setTaskRunArtifactsFromRunResult(sidecarLogResults, &tras)
errs = errors.Join(errs, err)
return errs

list appending isn't free, so it seems like using errors.Join each time may be preferable, but maybe not. Not sure what the best practice is here, hence my asking.

Good question. Looking at the implementation, errors.Join might not be the preferred way, as it loops through the errors multiple times.

Ah, you're right. Amortized errors.Join is going to result in more allocations in addition to the extra iteration, since append isn't going to make a new array every call but make certainly definitely will...

This shouldn't be necessary anymore, since we're no longer dealing the with MultiError custom type, and just dealing with the error type. We should be able to get away with just using c.wantErr without a wrapper. See this example

Please correct me if I'm mistaken, you want me to do something like this?:

gotErr := setTaskRunStatusBasedOnStepStatus(ctx, logger, []corev1.ContainerStatus{{}}, &c.tr, pod.Status.Phase, kubeclient, ts)
if gotErr == nil {
t.Fatalf("Expected error but got nil")
}
if d := cmp.Diff(c.wantErr.Error(), gotErr.Error()); d != "" {
t.Errorf("Got unexpected error %s", diff.PrintWantGot(d))
}

Exactly :)

Since this is no longer a multierror, do you mind renaming the variable to something more accurate? Maybe gotErr or err?

Whether or not we opt to use a errors.Join instead of append(errs, err), we can take advantage of errors.Join's ability to ignore nil input:
(if using errors.Join for each error - if previousErr is nil errors.Join() will ignore it at the next call to errors.Join(errs, err))

(if using append(errs, err) for each error, errors.Join will ignore a nil entry in the list when we return)